/**
 * 沙画应用云对象主入口
 * 参考uni-id-co封装方式实现国际化支持
 */
const uniIdCommon = require('uni-id-common')
const { 
	getLanguageFromClientInfo,
	checkClientInfo, 
	getType,
	universal
} = require('./common/utils')
const { 
	ERROR,
	isUniIdError 
} = require('./common/error')
const { configureModules } = require('./common/module-config')

// 导入业务模块
const sh_dict = require('./module/sh_dict')
const pattern = require('./module/sh_pattern')
const sh_device = require('./module/sh_device')
const sh_user = require('./module/sh_user')
const sh_user_device = require('./module/sh_user_device')
const sh_user_collection = require('./module/sh_user_collection')
const sh_user_playlist = require('./module/sh_user_playlist')
const sh_user_message = require('./module/sh_user_message')
const sh_user_share = require('./module/sh_user_share')
const sh_featured_playlist = require('./module/sh_featured_playlist')
const sh_user_favourite = require('./module/sh_user_favourite')

module.exports = {
	async _before() {
		// 支持 callFunction 与 URL化
		universal.call(this)
		
		// 获取客户端信息
		const clientInfo = this.getUniversalClientInfo()
		
		/**
		 * 检查clientInfo，无appId和uniPlatform时本云对象无法正常运行
		 * 此外需要保证用到的clientInfo字段均经过类型检查
		 */
		checkClientInfo(clientInfo)
		
		// 设置客户端平台信息
		this.clientPlatform = clientInfo.uniPlatform
		
		// 挂载uni-id实例到this上，方便后续调用
		this.uniIdCommon = uniIdCommon.createInstance({
			clientInfo
		})
		
		// 获取客户端语言设置
		this.language = getLanguageFromClientInfo(clientInfo)
		
		// 国际化配置
		const messages = require('./lang/index')
		const fallbackLocale = 'zh-Hans'
		const i18n = uniCloud.initI18n({
			locale: this.language,
			fallbackLocale,
			messages: JSON.parse(JSON.stringify(messages))
		})
		
		// 如果当前语言不支持，回退到默认语言
		if (!messages[i18n.locale]) {
			i18n.setLocale(fallbackLocale)
			this.language = fallbackLocale
		}
		
		// 绑定国际化翻译函数
		this.t = i18n.t.bind(i18n)
		
		// 统一配置所有业务模块的通用属性
		configureModules(this, [sh_dict, pattern, sh_device, sh_user, sh_user_device, sh_user_collection, sh_user_playlist, sh_user_message, sh_user_share, sh_featured_playlist, sh_user_favourite])
		
		// 初始化响应对象
		this.response = {}
		
		// 记录请求开始日志
		console.log(`[SANDART] Request started - Language: ${this.language}, Platform: ${this.clientPlatform}`)
	},
	
	_after(error, result) {
		if (error) {
			// 处理标准响应对象错误
			if (error.errCode && getType(error) === 'object') {
				const errCode = error.errCode
				
				// 检查是否为自定义错误码
				if (isUniIdError(errCode)) {
					return {
						errCode,
						errMsg: this.t(errCode, error.errMsgValue || {})
					}
				}
				
				// 返回原始错误
				return {
					errCode,
					errMsg: error.errMsg || this.t(errCode, error.errMsgValue || {})
				}
			}
			
			// 抛出非标准错误
			throw error
		}
		
		// 成功时合并响应对象
		return Object.assign(this.response, result)
	},
	
	// ======================== 字典管理 API ========================
	
	/**
	 * 获取字典数据列表
	 * @param {string} type 字典类型
	 * @param {object} options 查询选项
	 * @returns {object} 字典数据列表
	 */
	async getDictDatas(type, options = {}) {
		return await sh_dict.getDictDatas.call(this, type, options)
	},
	
	/**
	 * 获取全量字典数据并按dict_type分组
	 * @returns {object} 按dict_type分组的字典数据Map
	 */
	async getAllDictDataMap() {
		return await sh_dict.getAllDictDataMap.call(this)
	},
	
	// ======================== 图案管理 API ========================
	
	/**
	 * 获取图案列表
	 * @param {object} params 查询参数
	 * @returns {object} 图案列表
	 */
	async getPatternList(params = {}) {
		return await pattern.getPatternList.call(this, params)
	},
	
	/**
	 * 获取图案详情
	 * @param {string} patternId 图案ID
	 * @returns {object} 图案详情
	 */
	async getPatternDetail(patternId) {
		return await pattern.getPatternDetail.call(this, patternId)
	},

	/**
	 * 通过文件名获取图案详情
	 * @param {string} fileName 图案文件名
	 * @returns {object} 图案详情
	 */
	async getPatternByFileName(fileName) {
		return await pattern.getPatternByFileName.call(this, fileName)
	},
	
	// ======================== 设备管理 API ========================
	
	/**
	 * 获取用户设备列表
	 * @returns {object} 设备列表
	 */
	async getDeviceList() {
		return await sh_user_device.getDeviceList.call(this)
	},
	
	/**
	 * 添加设备
	 * @param {object} params 设备参数
	 * @returns {object} 添加结果
	 */
	async addDevice(params) {
		return await sh_user_device.addDevice.call(this, params)
	},
	
	/**
	 * 更新设备信息
	 * @param {object} params 更新参数
	 * @returns {object} 更新结果
	 */
	async updateDevice(params) {
		return await sh_user_device.updateDevice.call(this, params)
	},
	
	/**
	 * 删除设备
	 * @param {object} params 删除参数
	 * @returns {object} 删除结果
	 */
	async deleteDevice(params) {
		return await sh_user_device.deleteDevice.call(this, params)
	},
	
	/**
	 * 通过设备SN删除设备
	 * @param {object} params 删除参数
	 * @returns {object} 删除结果
	 */
	async deleteDeviceBySn(params) {
		return await sh_user_device.deleteDeviceBySn.call(this, params)
	},
	
	/**
	 * 移除设备分享（分享者退出设备）
	 * @param {object} params 参数
	 * @returns {object} 移除结果
	 */
	async removeDeviceShare(params) {
		return await sh_user_device.removeDeviceShare.call(this, params)
	},
	
	/**
	 * 控制设备
	 * @param {object} params 控制参数
	 * @returns {object} 控制结果
	 */
	async controlDevice(params) {
		return await sh_user_device.controlDevice.call(this, params)
	},
	
	/**
	 * 获取设备详情
	 * @param {object} params 查询参数
	 * @returns {object} 设备详情
	 */
	async getDeviceDetail(params) {
		return await sh_user_device.getDeviceDetail.call(this, params)
	},
	
	/**
	 * 更新设备状态
	 * @param {object} params 更新参数
	 * @returns {object} 更新结果
	 */
	async updateDeviceStatus(params) {
		return await sh_user_device.updateDeviceStatus.call(this, params)
	},
	
	// ======================== 收藏集管理 API ========================
	
	/**
	 * 获取用户收藏集列表
	 * @param {object} params 查询参数
	 * @returns {object} 收藏集列表
	 */
	async getCollectionList(params = {}) {
		return await sh_user_collection.getCollectionList.call(this, params)
	},
	
	/**
	 * 创建收藏集
	 * @param {object} params 创建参数
	 * @returns {object} 创建结果
	 */
	async createCollection(params) {
		return await sh_user_collection.createCollection.call(this, params)
	},
	
	/**
	 * 更新收藏集信息
	 * @param {object} params 更新参数
	 * @returns {object} 更新结果
	 */
	async updateCollection(params) {
		return await sh_user_collection.updateCollection.call(this, params)
	},
	
	/**
	 * 删除收藏集
	 * @param {object} params 删除参数
	 * @returns {object} 删除结果
	 */
	async deleteCollection(params) {
		return await sh_user_collection.deleteCollection.call(this, params)
	},
	
	/**
	 * 获取收藏集详情
	 * @param {object} params 查询参数
	 * @returns {object} 收藏集详情
	 */
	async getCollectionDetail(params) {
		return await sh_user_collection.getCollectionDetail.call(this, params)
	},
	
	/**
	 * 添加图案到收藏集
	 * @param {object} params 添加参数
	 * @returns {object} 添加结果
	 */
	async addPatternToCollection(params) {
		return await sh_user_collection.addPatternToCollection.call(this, params)
	},
	
	/**
	 * 从收藏集移除图案
	 * @param {object} params 移除参数
	 * @returns {object} 移除结果
	 */
	async removePatternFromCollection(params) {
		return await sh_user_collection.removePatternFromCollection.call(this, params)
	},
	
	/**
	 * 批量从收藏集移除图案
	 * @param {object} params 批量移除参数，包含 collection_id 和 pattern_ids
	 * @returns {object} 批量移除结果
	 */
	async batchRemovePatternsFromCollection(params) {
		return await sh_user_collection.batchRemovePatternsFromCollection.call(this, params)
	},
	
	/**
	 * 批量查询多个图案的收藏状态
	 * @param {object} params 查询参数，包含 pattern_ids 数组
	 * @returns {object} 图案收藏状态映射表
	 */
	async batchGetPatternsCollectionStatus(params) {
		return await sh_user_collection.batchGetPatternsCollectionStatus.call(this, params)
	},

	/**
	 * 根据图案ID获取包含该图案的收藏集列表
	 * @param {object} params 查询参数，包含 pattern_id
	 * @returns {object} 收藏集列表
	 */
	async getCollectionsByPattern(params) {
		return await sh_user_collection.getCollectionsByPattern.call(this, params)
	},
	
	/**
	 * 重新排序收藏集中的图案
	 * @param {object} params 排序参数
	 * @returns {object} 排序结果
	 */
	async reorderPatternsInCollection(params) {
		return await sh_user_collection.reorderPatternsInCollection.call(this, params)
	},

	// ==================== 播放列表管理 ====================
	
	/**
	 * 获取设备播放列表
	 * @param {object} params 查询参数
	 * @returns {object} 播放列表
	 */
	async getPlaylist(params) {
		return await sh_user_playlist.getPlaylist.call(this, params)
	},
	
	/**
	 * 添加图案到播放列表
	 * @param {object} params 添加参数
	 * @returns {object} 添加结果
	 */
	async addPatternToPlaylist(params) {
		return await sh_user_playlist.addPatternToPlaylist.call(this, params)
	},
	
	/**
	 * 从播放列表移除图案
	 * @param {object} params 移除参数
	 * @returns {object} 移除结果
	 */
	async removePatternFromPlaylist(params) {
		return await sh_user_playlist.removePatternFromPlaylist.call(this, params)
	},
	
	/**
	 * 重新排序播放列表中的图案
	 * @param {object} params 排序参数
	 * @returns {object} 排序结果
	 */
	async reorderPatternsInPlaylist(params) {
		return await sh_user_playlist.reorderPatternsInPlaylist.call(this, params)
	},
	
	/**
	 * 批量添加图案到播放列表
	 * @param {object} params 批量添加参数
	 * @returns {object} 批量添加结果
	 */
	async batchAddPatternsToPlaylist(params) {
		return await sh_user_playlist.batchAddPatternsToPlaylist.call(this, params)
	},
	
	/**
	 * 清空播放列表
	 * @param {object} params 清空参数
	 * @returns {object} 清空结果
	 */
	async clearPlaylist(params) {
		return await sh_user_playlist.clearPlaylist.call(this, params)
	},
	
	/**
	 * 批量添加图案到播放列表末尾
	 * @param {object} params 批量添加参数，包含 deviceId 和 patternIds
	 * @returns {object} 批量添加结果
	 */
	async batchAddPatternsToEnd(params) {
		return await sh_user_playlist.batchAddPatternsToEnd.call(this, params)
	},
	
	/**
	 * 立即播放（清空播放列表并添加指定图案）
	 * @param {object} params 立即播放参数，包含 deviceId 和 patternIds
	 * @returns {object} 立即播放结果
	 */
	async playNow(params) {
		return await sh_user_playlist.playNow.call(this, params)
	},
	
	/**
	 * 更新播放列表设置
	 * @param {object} params 更新参数
	 * @returns {object} 更新结果
	 */
	async updatePlaylistSettings(params) {
		return await sh_user_playlist.updatePlaylistSettings.call(this, params)
	},

	// ==================== 消息管理 API ====================
	
	/**
	 * 获取用户消息列表
	 * @param {object} params 查询参数
	 * @returns {object} 消息列表
	 */
	async getMessageList(params = {}) {
		return await sh_user_message.getMessageList.call(this, params)
	},
	
	/**
	 * 标记消息为已读
	 * @param {object} params 标记参数
	 * @returns {object} 标记结果
	 */
	async markMessageAsRead(params) {
		return await sh_user_message.markAsRead.call(this, params)
	},
	
	/**
	 * 批量标记消息为已读
	 * @param {object} params 批量标记参数
	 * @returns {object} 标记结果
	 */
	async batchMarkMessagesAsRead(params) {
		return await sh_user_message.batchMarkAsRead.call(this, params)
	},
	
	/**
	 * 删除消息
	 * @param {object} params 删除参数
	 * @returns {object} 删除结果
	 */
	async deleteMessage(params) {
		return await sh_user_message.deleteMessage.call(this, params)
	},
	
	/**
	 * 批量删除消息
	 * @param {object} params 批量删除参数
	 * @returns {object} 删除结果
	 */
	async batchDeleteMessages(params) {
		return await sh_user_message.batchDeleteMessages.call(this, params)
	},
	
	/**
	 * 发送系统消息
	 * @param {object} params 发送参数
	 * @returns {object} 发送结果
	 */
	async sendSystemMessage(params) {
		return await sh_user_message.sendSystemMessage.call(this, params)
	},
	
	/**
	 * 批量发送系统消息
	 * @param {object} params 批量发送参数
	 * @returns {object} 批量发送结果
	 */
	async batchSendSystemMessage(params) {
		return await sh_user_message.batchSendSystemMessage.call(this, params)
	},
	
	/**
	 * 获取未读消息数量
	 * @returns {object} 未读数量
	 */
	async getUnreadMessageCount() {
		return await sh_user_message.getUnreadCount.call(this)
	},
	
	/**
	 * 全部标记为已读
	 * @returns {object} 标记结果
	 */
	async markAllMessagesAsRead() {
		return await sh_user_message.markAllAsRead.call(this)
	},
	
	/**
	 * 获取消息详情
	 * @param {object} params 查询参数
	 * @returns {object} 消息详情
	 */
	async getMessageDetail(params) {
		return await sh_user_message.getMessageDetail.call(this, params)
	},
	
	/**
	 * 获取消息统计信息
	 * @param {object} params 查询参数
	 * @returns {object} 统计信息
	 */
	async getMessageStats(params = {}) {
		return await sh_user_message.getMessageStats.call(this, params)
	},

	// ==================== 设备分享管理 API ====================
	
	/**
	 * 创建设备分享
	 * @param {object} params 分享参数
	 * @returns {object} 分享结果
	 */
	async createDeviceShare(params) {
		return await sh_user_share.createShare.call(this, params)
	},
	
	/**
	 * 接受分享邀请
	 * @param {object} params 接受参数
	 * @returns {object} 接受结果
	 */
	async acceptDeviceShare(params) {
		return await sh_user_share.acceptShare.call(this, params)
	},
	
	/**
	 * 拒绝分享邀请
	 * @param {object} params 拒绝参数
	 * @returns {object} 拒绝结果
	 */
	async rejectDeviceShare(params) {
		return await sh_user_share.rejectShare.call(this, params)
	},
	
	/**
	 * 撤销设备分享
	 * @param {object} params 撤销参数
	 * @returns {object} 撤销结果
	 */
	async revokeDeviceShare(params) {
		return await sh_user_share.revokeShare.call(this, params)
	},
	
	/**
	 * 获取设备分享列表
	 * @param {object} params 查询参数
	 * @returns {object} 分享列表
	 */
	async getDeviceShareList(params) {
		return await sh_user_share.getDeviceShareList.call(this, params)
	},
	
	/**
	 * 获取用户收到的分享邀请
	 * @param {object} params 查询参数
	 * @returns {object} 邀请列表
	 */
	async getUserShareInvites(params = {}) {
		return await sh_user_share.getUserShareInvites.call(this, params)
	},
	
	/**
	 * 获取用户分享的设备列表
	 * @param {object} params 查询参数
	 * @returns {object} 分享设备列表
	 */
	async getSharedDevices(params = {}) {
		return await sh_user_share.getSharedDevices.call(this, params)
	},
	
	/**
	 * 更新分享权限
	 * @param {object} params 更新参数
	 * @returns {object} 更新结果
	 */
	async updateSharePermissions(params) {
		return await sh_user_share.updateSharePermissions.call(this, params)
	},

	// ==================== 热门播放列表管理 API ====================
	
	/**
	 * 获取热门播放列表
	 * @param {object} params 查询参数
	 * @param {number} [params.limit=10] 获取数量，默认10条
	 * @returns {object} 热门播放列表
	 */
	async getFeaturedPlaylists(params = {}) {
		return await sh_featured_playlist.getFeaturedPlaylists.call(this, params)
	},
	
	/**
	 * 获取热门播放列表详情
	 * @param {object} params 查询参数
	 * @param {string} params.playlist_id 播放列表ID
	 * @returns {object} 播放列表详情
	 */
	async getFeaturedPlaylistDetail(params) {
		return await sh_featured_playlist.getPlaylistDetail.call(this, params)
	},

	// ==================== 用户喜欢管理 API ====================
	
	/**
	 * 获取用户喜欢的图案列表
	 * @param {object} params 查询参数
	 * @param {number} [params.page=1] 页码
	 * @param {number} [params.limit=20] 每页数量
	 * @returns {object} 喜欢的图案列表
	 */
	async getUserFavourites(params = {}) {
		return await sh_user_favourite.getUserFavourites.call(this, params)
	},
	
	/**
	 * 添加图案到喜欢列表
	 * @param {object} params 添加参数
	 * @param {string} params.pattern_id 图案ID
	 * @returns {object} 添加结果
	 */
	async addPatternToFavourites(params) {
		return await sh_user_favourite.addPatternToFavourites.call(this, params)
	},
	
	/**
	 * 从喜欢列表移除图案
	 * @param {object} params 移除参数
	 * @param {string} params.pattern_id 图案ID
	 * @returns {object} 移除结果
	 */
	async removePatternFromFavourites(params) {
		return await sh_user_favourite.removePatternFromFavourites.call(this, params)
	},
	
	/**
	 * 检查图案是否在用户喜欢列表中
	 * @param {object} params 检查参数
	 * @param {string} params.pattern_id 图案ID
	 * @returns {object} 检查结果
	 */
	async checkPatternInFavourites(params) {
		return await sh_user_favourite.checkPatternInFavourites.call(this, params)
	},
	
	/**
	 * 清空用户喜欢列表
	 * @returns {object} 清空结果
	 */
	async clearUserFavourites() {
		return await sh_user_favourite.clearUserFavourites.call(this)
	},
	
	// ======================== 数据迁移脚本 ========================
	
	/**
	 * 迁移图案数据格式
	 * 用途：
	 * 1. 将 category 从对象格式转换为字符串
	 * 2. 将 tags 从对象数组转换为字符串数组
	 * 3. 将所有图案的 duration 设置为 60
	 * @returns {object} 迁移结果
	 */
	async migratePatternData() {
		const { migratePatternData } = require('./scripts/migrate_pattern_data')
		return await migratePatternData()
	}
}
